// src/services/auth.js - 认证相关服务

import { post, get } from './api';
import {
  loginUser as localLoginUser,
  registerUser as localRegisterUser,
  saveUser as localSaveUser,
  removeUser as localRemoveUser,
  getUser as localGetUser,
  validateInviteCode as localValidateInviteCode
} from '../utils/localStorage';

/**
 * 用户登录
 * @param {string} username - 用户名
 * @param {string} password - 密码
 * @returns {Promise} - 登录结果
 */
export const login = async (username, password) => {
  try {
    // 调用后端登录接口，路径为/login
    const response = await post('/login', { username, password });

    // 处理后端响应
    // 根据后端实现，返回的格式为：{ code: 200, message: "操作成功", data: token }
    if (response && response.code === 200) {
      // 获取token（在响应的data字段中）
      const token = response.data;

      // 保存令牌到localStorage
      localStorage.setItem('token', token);

      try {
        // 使用token获取用户完整信息
        const userInfoResponse = await get('/user/auth/me');
        let userInfo = null;

        if (userInfoResponse && userInfoResponse.code === 200) {
          userInfo = userInfoResponse.data.user;
        } else {
          // 如果获取用户信息失败，使用基本信息
          userInfo = {
            username: username,
            email: null  // 设置为null，后续可以检查
          };
        }

        localSaveUser(userInfo);

        // 转换为前端统一的响应格式
        return {
          success: true,
          message: response.message || '登录成功',
          data: {
            token: token,
            user: userInfo
          }
        };
      } catch (userInfoError) {
        console.warn('获取用户信息失败:', userInfoError);

        // 获取用户信息失败，但登录成功，保存基本信息
        const basicUserInfo = {
          username: username,
          email: null  // 设置为null，后续可以检查
        };
        localSaveUser(basicUserInfo);

        return {
          success: true,
          message: response.message || '登录成功',
          data: {
            token: token,
            user: basicUserInfo
          }
        };
      }
    } else {
      // 处理错误响应
      return {
        success: false,
        message: response.message || '登录失败',
        error: {
          code: response.code
        }
      };
    }
  } catch (error) {
    console.warn('登录API连接失败，使用本地存储:', error);

    // 从localStorage模拟登录
    const result = localLoginUser(username, password);

    if (result.success) {
      localSaveUser(result.user);
      // 模拟API响应格式
      return {
        success: true,
        message: '登录成功',
        data: {
          token: 'local-storage-mock-token',
          user: result.user
        }
      };
    } else {
      throw new Error(result.message || '登录失败');
    }
  }
};

/**
 * 用户注册
 * @param {Object} userData - 用户数据
 * @returns {Promise} - 注册结果
 */
export const register = async (userData) => {
  try {
    // 根据后端API格式调整数据
    const registerData = {
      username: userData.username,
      password: userData.password,
      email: userData.email,
      isInvited: userData.isInvited ? "true" : "false",
      code: userData.isInvited ? userData.code : undefined
    };

    // 调用后端注册接口
    const response = await post('/register', registerData);

    // 处理后端响应
    if (response && response.code === 200) {
      return {
        success: true,
        message: response.message || '注册成功',
        data: response.data || {}
      };
    } else {
      // 根据后端错误码返回相应的错误信息
      let errorMessage = response.message || '注册失败';

      switch (response.code) {
        case 404:
          errorMessage = '邀请码不存在';
          break;
        case 406:
          errorMessage = '用户名已存在';
          break;
        case 409:
          errorMessage = '邀请码已被使用';
          break;
        case 422:
          errorMessage = '邮箱域名与邀请码创建者域名不匹配';
          break;
        case 500:
          errorMessage = '服务器内部错误，注册失败';
          break;
        default:
          errorMessage = response.message || '注册失败';
      }

      return {
        success: false,
        message: errorMessage,
        error: {
          code: response.code
        }
      };
    }
  } catch (error) {
    console.warn('注册API连接失败，使用本地存储或处理错误:', error);

    // 检查是否是HTTP错误响应
    if (error.response) {
      // 根据后端返回的状态码设置前端错误对象
      const statusCode = error.response.status;
      let errorMessage = error.response.data?.message || '注册失败';

      // 根据状态码提供更友好的错误信息
      switch (statusCode) {
        case 404:
          errorMessage = '邀请码不存在';
          break;
        case 406:
          errorMessage = '用户名已存在';
          break;
        case 409:
          errorMessage = '邀请码已被使用';
          break;
        case 422:
          errorMessage = '邮箱域名与邀请码创建者域名不匹配';
          break;
        case 500:
          errorMessage = '服务器内部错误，注册失败';
          break;
      }

      const errorObj = new Error(errorMessage);
      errorObj.code = statusCode;

      throw errorObj;
    }

    // 如果是网络错误或API不可达，使用本地存储模拟注册
    try {
      // 从userData中提取数据
      const { username, password, email, isInvited, code } = userData;

      // 如果选择了邀请注册，先在本地验证邀请码
      if (isInvited && code) {
        const isValid = localValidateInviteCode(code, email);
        if (!isValid) {
          const errorObj = new Error('邀请码无效或域名不匹配');
          errorObj.code = 422;
          throw errorObj;
        }
      }

      // 使用本地存储模拟注册
      const result = localRegisterUser(username, password, email, isInvited ? code : null);

      if (result.success) {
        return {
          success: true,
          message: '注册成功',
          data: {
            user: result.user
          }
        };
      } else {
        // 处理本地注册失败
        const errorObj = new Error(result.message || '注册失败');
        if (result.message?.includes('用户名已存在')) {
          errorObj.code = 406;
        }
        throw errorObj;
      }
    } catch (localError) {
      // 如果本地处理也失败，抛出错误
      throw localError;
    }
  }
};

/**
 * 用户登出
 * @returns {Promise} - 登出结果
 */
export const logout = async () => {
  // 清除本地存储的令牌和用户数据
  localStorage.removeItem('token');
  localRemoveUser();

  // 返回成功结果
  return {
    success: true,
    message: '登出成功'
  };
};

/**
 * 获取当前登录用户信息
 * @returns {Promise} - 用户信息
 */
export const getCurrentUser = async () => {
  try {
    const response = await get('/user/auth/me');

    // 处理后端响应
    if (response && response.code === 200) {
      const userData = response.data.user;

      // 更新本地用户信息
      localSaveUser(userData);

      return {
        success: true,
        data: {
          user: userData
        }
      };
    } else {
      return {
        success: false,
        message: response.message || '获取用户信息失败',
        error: {
          code: response.code
        }
      };
    }
  } catch (error) {
    console.warn('获取用户信息API连接失败，使用本地存储:', error);

    // 从localStorage获取用户信息
    const user = localGetUser();

    if (user) {
      return {
        success: true,
        data: {
          user
        }
      };
    } else {
      throw new Error('未登录或会话已过期');
    }
  }
};

/**
 * 检查用户是否已登录
 * @returns {boolean} - 是否已登录
 */
export const isLoggedIn = () => {
  return !!localStorage.getItem('token') || !!localGetUser();
};

export default {
  login,
  register,
  logout,
  getCurrentUser,
  isLoggedIn
}; 